package cn.com.anypay.manager.common.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.Map;

/**
 * JSON 工具类
 * 基于 Jackson 的 JSON 序列化/反序列化工具
 */
public final class AnyJsonUtils {

    private static final Logger logger = LoggerFactory.getLogger(AnyJsonUtils.class);

    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    static {
        // 配置 ObjectMapper
        OBJECT_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        OBJECT_MAPPER.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        OBJECT_MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        OBJECT_MAPPER.registerModule(new JavaTimeModule());

        // 确保使用UTF-8编码
        OBJECT_MAPPER.getFactory().setCharacterEscapes(null);
    }

    // 防止实例化
    private AnyJsonUtils() {}

    /**
     * 对象转JSON字符串
     */
    public static String toJsonString(Object obj) {
        if (obj == null) {
            return null;
        }
        try {
            return OBJECT_MAPPER.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            logger.error("对象转JSON字符串失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 对象转格式化的JSON字符串
     */
    public static String toPrettyJsonString(Object obj) {
        if (obj == null) {
            return null;
        }
        try {
            return OBJECT_MAPPER.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            logger.error("对象转格式化JSON字符串失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * JSON字符串转对象
     */
    public static <T> T parseObject(String jsonStr, Class<T> clazz) {
        if (StringUtils.isBlank(jsonStr) || clazz == null) {
            return null;
        }
        try {
            return OBJECT_MAPPER.readValue(jsonStr, clazz);
        } catch (JsonProcessingException e) {
            logger.error("JSON字符串转对象失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * JSON字符串转对象（泛型支持）
     */
    public static <T> T parseObject(String jsonStr, TypeReference<T> typeReference) {
        if (StringUtils.isBlank(jsonStr) || typeReference == null) {
            return null;
        }
        try {
            return OBJECT_MAPPER.readValue(jsonStr, typeReference);
        } catch (JsonProcessingException e) {
            logger.error("JSON字符串转对象失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * JSON字符串转List
     */
    public static <T> List<T> parseList(String jsonStr, Class<T> clazz) {
        if (StringUtils.isBlank(jsonStr) || clazz == null) {
            return null;
        }
        try {
            return OBJECT_MAPPER.readValue(jsonStr,
                OBJECT_MAPPER.getTypeFactory().constructCollectionType(List.class, clazz));
        } catch (JsonProcessingException e) {
            logger.error("JSON字符串转List失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * JSON字符串转Map
     */
    public static Map<String, Object> parseMap(String jsonStr) {
        if (StringUtils.isBlank(jsonStr)) {
            return null;
        }
        try {
            return OBJECT_MAPPER.readValue(jsonStr, new TypeReference<Map<String, Object>>() {});
        } catch (JsonProcessingException e) {
            logger.error("JSON字符串转Map失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 对象转Map<String, Object>
     * 支持JSON字符串和任意对象转换为Map类型
     * 使用方可以根据需要自行处理值的类型转换
     *
     * @param obj 要转换的对象（可以是JSON字符串或其他对象）
     * @return Map<String, Object> 转换后的Map，失败时返回null
     */
    public static Map<String, Object> toMap(Object obj) {
        if (obj == null) {
            return null;
        }

        // 如果是字符串，按JSON字符串处理
        if (obj instanceof String) {
            return parseMap((String) obj);
        }

        // 其他对象类型，使用convertValue转换
        try {
            return OBJECT_MAPPER.convertValue(obj, new TypeReference<Map<String, Object>>() {});
        } catch (IllegalArgumentException e) {
            logger.error("对象转Map失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * JSON字符串转指定类型的Map
     */
    public static <K, V> Map<K, V> parseMap(String jsonStr, Class<K> keyClass, Class<V> valueClass) {
        if (StringUtils.isBlank(jsonStr) || keyClass == null || valueClass == null) {
            return null;
        }
        try {
            return OBJECT_MAPPER.readValue(jsonStr,
                OBJECT_MAPPER.getTypeFactory().constructMapType(Map.class, keyClass, valueClass));
        } catch (JsonProcessingException e) {
            logger.error("JSON字符串转Map失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 对象转换（通过JSON序列化/反序列化）
     */
    public static <T> T convertValue(Object fromValue, Class<T> toValueType) {
        if (fromValue == null || toValueType == null) {
            return null;
        }
        try {
            return OBJECT_MAPPER.convertValue(fromValue, toValueType);
        } catch (IllegalArgumentException e) {
            logger.error("对象转换失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 对象转换（泛型支持）
     */
    public static <T> T convertValue(Object fromValue, TypeReference<T> toValueTypeRef) {
        if (fromValue == null || toValueTypeRef == null) {
            return null;
        }
        try {
            return OBJECT_MAPPER.convertValue(fromValue, toValueTypeRef);
        } catch (IllegalArgumentException e) {
            logger.error("对象转换失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 验证JSON字符串格式是否正确
     */
    public static boolean isValidJson(String jsonStr) {
        if (StringUtils.isBlank(jsonStr)) {
            return false;
        }
        try {
            OBJECT_MAPPER.readTree(jsonStr);
            return true;
        } catch (JsonProcessingException e) {
            return false;
        }
    }

        /**
     * 安全地从Object中获取Map类型的值
     * 使用Jackson的convertValue方法，避免unchecked警告
     *
     * @param obj 需要转换的对象
     * @param fieldName 字段名（用于错误信息）
     * @return Map<String, Object> 转换后的Map
     * @throws RuntimeException 如果对象不能转换为Map类型
     */
    public static Map<String, Object> getMapFromObject(Object obj, String fieldName) {
        if (obj == null) {
            return null;
        }
        try {
            return OBJECT_MAPPER.convertValue(obj, new TypeReference<Map<String, Object>>() {});
        } catch (IllegalArgumentException e) {
            throw new RuntimeException("响应格式错误：" + fieldName + " 不能转换为 Map 类型，实际类型：" +
                (obj != null ? obj.getClass().getSimpleName() : "null") + "，错误：" + e.getMessage());
        }
    }

    /**
     * 获取ObjectMapper实例
     */
    public static ObjectMapper getObjectMapper() {
        return OBJECT_MAPPER;
    }
}